home *** CD-ROM | disk | FTP | other *** search
/ PC Electronics Plus 3 / PC Electronics Plus 3.iso / astater / astater.doc next >
Text File  |  1994-09-01  |  45KB  |  1,424 lines
  1. page 1
  2.           ┌────────────────────────────────────────────────────────┐
  3.           │ ASTATER.EXE Version 1.0 - AHDL State Machine Generator │
  4.           └────────────────────────────────────────────────────────┘
  5.  
  6.            (C)Copyright & Support - Amos Zaslavsky @ 972-4-230219.
  7.  
  8.    Description ........................................................  1
  9.    Command line syntax ................................................  2
  10.    Example 1 : A Mealy machine with fully encoded state assignment ....  3
  11.    Example 2 : A Mealy machine with One-Hot state assignment .......... 11
  12.    Example 3 : A Moore machine with direct outputs .................... 15
  13.    Example 4 : A Moore mixed example .................................. 21
  14.    Errors, Warning & Note Messages .................................... 28
  15.    Limitations & Legal details ........................................ 32
  16.  
  17.                                  Description
  18.                                 -------------
  19.  
  20. ASTATER.EXE is a utility for generating an ABEL file for state machines.
  21.  
  22. It will generate a file template that will fit your requirements of:
  23.  
  24. - number of inputs
  25. - number of outputs
  26. - maximum number of relevant conditions per state
  27. - number of flip flops
  28. - state names
  29.  
  30. After generation of the state machine file you will have to make a few
  31. changes to the file with your text editor. This utility can save time and let
  32. you concentrate on the logic of the machine an not on the syntax. The program
  33. is simpler to use then some fancy graphical state machine generators that
  34. are on the market (which are also expensive).
  35.  
  36. The original idea of a stater program came from Ofer Hoffman (A VHDL shark
  37. @ 972-4-230048) how wrote a program like this for VHDL users !
  38.  
  39.  page 2
  40.                              Command line syntax
  41.                             ---------------------
  42.  
  43. ASTATER must be followed by eight command line parameters:
  44.  
  45.  ASTATER <module> <in> <out> <con> <ff> /1|2 <state_name> <state_name>...
  46.  
  47.   <module>  Is the module name. This will also be the file name and device
  48.             name.
  49.  
  50.   <in>      Is the number of inputs. At least one input must be defined.
  51.  
  52.   <out>     Number of indirect outputs. Indirect output is an output that is
  53.             not a direct flip flop output.
  54.  
  55.   <cond>    Is the maximum number of relevant condition per state. A machine
  56.             can have many inputs (for example 15: I1,I2...I15), but in each
  57.             state only a small number of conditions is relevant. for example:
  58.  
  59.             condition1 -   I1 & !I2
  60.             condition2 -   I1 &  I2
  61.             condition3 -  !I1
  62.  
  63.             (in this example only 3 conditions). The maximum number of
  64.             conditions is 2^(inputs). A condition is not only a single input
  65.             signal (literal) but a can be a function of such signals (Like in
  66.             the previous example).
  67.  
  68.   <ff>      Number of flip-flops. A state machine must have at least one
  69.             flip-flop. If it has no flip-flops it is not a synchronous state
  70.             machine. If you plan to use one of the Flip-Flop outputs as an
  71.             output of the machine (a good way to prevent output spikes), don't
  72.             count it as an output of the machine. Such an output is called in
  73.             this document - "A direct output". Only indirect outputs should be
  74.             counted as outputs of the machine.
  75.  
  76.   /1|2      Type of machine:
  77.  
  78.             /1 - Moore machine (outputs depend only of the present state of
  79.                                 the machine)
  80.             /2 - Mealy machine (outputs depend both on the present state of
  81.                                 the machine and the inputs)
  82.             /3 - Dummy machine (A moore machine that can be compiled with on
  83.                                 modifications. The machine is a cyclic counter
  84.                                 enabled by the "input1" signal. The number of
  85.                                 conditions that you enter as command line is
  86.                                 not relevant.)
  87.  
  88.   <state>   A state name. A list of state names must have at least tow
  89.             members, but can have more.
  90.  
  91.  page 3
  92.  
  93.        Example 1 : A Mealy machine with fully encoded state assignment
  94.        ---------------------------------------------------------------
  95.  
  96. In this example we will describe a Mealy state machine with 3 inputs and 3
  97. outputs.
  98.  
  99.                                  ┌─────────┐
  100.                            U ───>┤         ├──>─ R
  101.                 Inputs     V ───>┤    M1   ├──>─ S     Outputs
  102.                            W ───>┤         ├──>─ T
  103.                                  └────┬────┘
  104.                                       │
  105.                               Cp ──>──┘
  106.  
  107.  
  108. This is a state-table of the machine:
  109.  
  110.             ┌───────────────┬─────────┬┬───────────────┬─────────┐
  111.             │ Present State │  Input  ││  Next State   │ Output  │
  112.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  113.             │       AA      │   !U    ││      AA       │    R    │
  114.             │               │    U    ││      BB       │    R    │
  115.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  116.             │       BB      │   !V    ││      CC       │   S,T   │
  117.             │               │    V    ││      DD       │   S     │
  118.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  119.             │       CC      │ !V & W  ││      CC       │    -    │
  120.             │               │  V & W  ││      DD       │    -    │
  121.             │               │     !W  ││      AA       │    -    │
  122.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  123.             │       DD      │    1    ││      AA       │   R,S   │
  124.             └───────────────┴─────────┴┴───────────────┴─────────┘
  125.  
  126.  
  127. It is easy to see from the table that the maximum number of transition
  128. conditions per state is three. The behavior of this machine is a Mealy
  129. behavior only when the machine is in state BB (and it's enough to make it a
  130. Mealy machine). When the machine is in state DD it makes an un-conditional
  131. transition (Autonomous) to the AA state.
  132.  
  133. In This example we will use a full binary encoding of state assignments. For
  134. this kind of encoding we need only tow flip-flops. In the next example we will
  135. use a One-Hot decoded state assignments. In the next example four flip-flops
  136. will be needed.
  137.  
  138.  page 4
  139.  
  140. For this example ASTATER.EXE will be used with The following command line
  141. parameters:
  142.  
  143.                3 - inputs
  144.                3 - outputs
  145.                3 - conditions
  146.                2 - flip-flops
  147.               /2 - Mealy machine
  148.               AA - first state
  149.               BB - second state
  150.               CC - third state
  151.               DD - forth state
  152.  
  153. Here is the command line you have to type:
  154.  
  155. ASTATER M1 3 3 3 2 /2 AA BB CC DD
  156.  
  157. Here is the file that will be created by ASTATER.EXE :
  158.  
  159.  
  160.                                     M1.ABL
  161. ┌─
  162. │MODULE M1
  163. │TITLE 'M1.ABL created by ASTATER.EXE Version 1.0
  164. │       Time of creation is Sat Aug 20 17:07:13 1994
  165. │      '
  166. │DECLARATIONS
  167. │
  168. │   M1 DEVICE ;
  169. │   input1 PIN ;
  170. │   input2 PIN ;
  171. │   input3 PIN ;
  172. │   CP PIN ; "CLOCK INPUT"
  173. │   MR PIN ; "MASTER RESET (ASYN) INPUT"
  174. │   output1 PIN ISTYPE 'COM' ;
  175. │   output2 PIN ISTYPE 'COM' ;
  176. │   output3 PIN ISTYPE 'COM' ;
  177. │   Q1 NODE ISTYPE 'REG,BUFFER' ;
  178. │   Q0 NODE ISTYPE 'REG,BUFFER' ;
  179. │
  180. │   PS = [Q1,Q0] ; "STATE ASSIGNMENT"
  181. │   AA = [ 0, 0] ;
  182. │   BB = [ 0, 0] ;
  183. │   CC = [ 0, 0] ;
  184. │   DD = [ 0, 0] ;
  185. │
  186. │   C , X , P , Z = .C. , .X. , .P. , .Z. ;
  187. │  page 5
  188.  
  189. │EQUATIONS
  190. │
  191. │PS.AR = !MR ;
  192. │   PS.CLK = CP ;
  193. │
  194. │STATE_DIAGRAM PS
  195. │
  196. │   STATE AA :
  197. │      [output1,output2,output3]=[0,0,0] ;
  198. │      CASE
  199. │         condition11 : next_state11
  200. │            WITH
  201. │               [output1,output2,output3]=[0,0,0] ;
  202. │            ENDWITH ;
  203. │         condition12 : next_state12
  204. │            WITH
  205. │               [output1,output2,output3]=[0,0,0] ;
  206. │            ENDWITH ;
  207. │         condition13 : next_state13
  208. │            WITH
  209. │               [output1,output2,output3]=[0,0,0] ;
  210. │            ENDWITH ;
  211. │      ENDCASE ;
  212. │   STATE BB :
  213. │      [output1,output2,output3]=[0,0,0] ;
  214. │      CASE
  215. │         condition21 : next_state21
  216. │            WITH
  217. │               [output1,output2,output3]=[0,0,0] ;
  218. │            ENDWITH ;
  219. │         condition22 : next_state22
  220. │            WITH
  221. │               [output1,output2,output3]=[0,0,0] ;
  222. │            ENDWITH ;
  223. │         condition23 : next_state23
  224. │            WITH
  225. │               [output1,output2,output3]=[0,0,0] ;
  226. │            ENDWITH ;
  227. │      ENDCASE ;
  228. │   STATE CC :
  229.  pgage 6
  230.  
  231. │      [output1,output2,output3]=[0,0,0] ;
  232. │      CASE
  233. │         condition31 : next_state31
  234. │            WITH
  235. │               [output1,output2,output3]=[0,0,0] ;
  236. │            ENDWITH ;
  237. │         condition32 : next_state32
  238. │            WITH
  239. │               [output1,output2,output3]=[0,0,0] ;
  240. │            ENDWITH ;
  241. │         condition33 : next_state33
  242. │            WITH
  243. │               [output1,output2,output3]=[0,0,0] ;
  244. │            ENDWITH ;
  245. │      ENDCASE ;
  246. │   STATE DD :
  247. │      [output1,output2,output3]=[0,0,0] ;
  248. │      CASE
  249. │         condition41 : next_state41
  250. │            WITH
  251. │               [output1,output2,output3]=[0,0,0] ;
  252. │            ENDWITH ;
  253. │         condition42 : next_state42
  254. │            WITH
  255. │               [output1,output2,output3]=[0,0,0] ;
  256. │            ENDWITH ;
  257. │         condition43 : next_state43
  258. │            WITH
  259. │               [output1,output2,output3]=[0,0,0] ;
  260. │            ENDWITH ;
  261. │      ENDCASE ;
  262. │
  263. │DECLARATIONS
  264. │
  265. │   NS = [Q1,Q0] ; "NEXT STATE"
  266. │
  267. │TEST_VECTORS
  268. │
  269. │   ([MR,CP,input1,input2,input3] -> [NS,output1,output2,output3])
  270. │
  271. │END
  272. └─
  273.  
  274. All the place holders were generated by ASTATER.EXE in lowercase letters.
  275. Using the replace function of your editor (a global replace) do the folowing
  276. replacements:
  277.  
  278.  page 7
  279.  
  280. - Replace input1 with U
  281.  
  282. - Replace input2 with V
  283.  
  284. - Replace input3 with W
  285.  
  286. - Replace output1 with R
  287.  
  288. - Replace output2 with S
  289.  
  290. - Replace output3 with T
  291.  
  292. Now do the folowing changes:
  293.  
  294. - Make state assignments.
  295.  
  296.   for example:
  297.  
  298.                 AA = [0,0], BB = [0,1], CC = [1,0], DD = [1,1]
  299.  
  300.   The assignment of combination [0,0] to state AA and the declarations of
  301.   attributes 'REG,BUFFER' that were chosen for Q1 and Q0, make the AA state
  302.   the reset state of the machine. It is not hard to change it.
  303.  
  304. - Delete the WITH..ENDWITH blocks from first, third and last state blocks.
  305.   These blocks desribe Mealy type behavior, and these blocks are Moore type
  306.   blocks (only the second block describes a Mealy behavior).
  307.  
  308. - Replace dummy conditions (condition1,condition2...) and next_states
  309.   (next_state1, next_state2...) , with real conditions and real next_states
  310.   and delete lines that are not needed.
  311.  
  312.   It is possible to describe an unconditional transition with ABEL's CASE
  313.   statements in the following way:
  314.  
  315.     STATE DD :
  316.        [R,S,T]=[1,1,0] ;
  317.        CASE
  318.           1 : AA                   <- this is the unconditional transition
  319.        ENDCASE ;
  320.  
  321.   it is equivalent to the folowing statements:
  322.  
  323.     STATE DD :
  324.        [R,S,T]=[1,1,0] ;
  325.        GOTO AA
  326.  page 8
  327.  
  328. - Replace zero output assignments (Mealy and Moore type) with real (0 or 1)
  329.   output assignments and delete output assignments that are not needed.
  330.  
  331. - Add test vector values.
  332.  
  333. Now the file will look like this:
  334.  
  335.                                     M1.ABL
  336. ┌─
  337. │MODULE M1
  338. │TITLE 'M1.ABL created by ASTATER.EXE Version 1.0
  339. │       Time of creation is Sat Aug 20 17:07:13 1994
  340. │      '
  341. │DECLARATIONS
  342. │
  343. │   M1 DEVICE ;
  344. │   U PIN ;
  345. │   V PIN ;
  346. │   W PIN ;
  347. │   CP PIN ; "CLOCK INPUT"
  348. │   MR PIN ; "MASTER RESET (ASYN) INPUT"
  349. │   R PIN ISTYPE 'COM' ;
  350. │   S PIN ISTYPE 'COM' ;
  351. │   T PIN ISTYPE 'COM' ;
  352. │   Q1 NODE ISTYPE 'REG,BUFFER' ;
  353. │   Q0 NODE ISTYPE 'REG,BUFFER' ;
  354. │
  355. │   PS = [Q1,Q0] ; "STATE ASSIGNMENT"
  356. │   AA = [ 0, 0] ;
  357. │   BB = [ 0, 1] ;
  358. │   CC = [ 1, 0] ;
  359. │   DD = [ 1, 1] ;
  360. │
  361. │   C , X , P , Z = .C. , .X. , .P. , .Z. ;
  362. │
  363. │EQUATIONS
  364. │
  365. │   PS.AR = !MR ;
  366. │   PS.CLK = CP ;
  367. │  page 9
  368. │STATE_DIAGRAM PS
  369. │
  370. │   STATE AA :
  371. │      [R,S,T]=[1,0,0] ;
  372. │      CASE
  373. │         !U : AA
  374. │          U : BB
  375. │      ENDCASE ;
  376. │   STATE BB :
  377. │      [R,S]=[0,1] ;
  378. │      CASE
  379. │         !V : CC
  380. │            WITH
  381. │               T = 1 ;
  382. │            ENDWITH ;
  383. │          V : DD
  384. │            WITH
  385. │               T = 0 ;
  386. │            ENDWITH ;
  387. │      ENDCASE ;
  388. │   STATE CC :
  389. │      [R,S,T]=[0,0,0] ;
  390. │      CASE
  391. │         !V & W : CC
  392. │          V & W : DD
  393. │             !W : AA
  394. │      ENDCASE ;
  395. │   STATE DD :
  396. │      [R,S,T]=[1,1,0] ;
  397. │      CASE
  398. │         1 : AA
  399. │      ENDCASE ;
  400. │
  401. │DECLARATIONS
  402. │
  403. │   NS = [Q1,Q0] ; "NEXT STATE"
  404. │  page 10
  405. │TEST_VECTORS
  406. │
  407. │  ([MR,CP,U,V,W] -> [PS,R,S,T])
  408. │   [ 0, X,X,X,X] -> [AA,1,0,0]; "RESET"
  409. │   [ 1, C,0,X,X] -> [AA,1,0,0]; "AA->AA"
  410. │   [ 1, C,1,X,X] -> [BB,0,1,X]; "AA->BB (T IS X)"
  411. │   [ 1, 0,X,0,X] -> [BB,0,1,1]; "BB/T"
  412. │   [ 1, 0,X,1,X] -> [BB,0,1,0]; "BB/!T"
  413. │   [ 1, C,X,0,X] -> [CC,0,0,0]; "BB->CC"
  414. │   [ 1, C,X,0,1] -> [CC,0,0,0]; "CC->CC"
  415. │   [ 1, C,X,X,0] -> [AA,1,0,0]; "CC->AA"
  416. │   [ 1, C,1,X,X] -> [BB,0,1,X]; "AA->BB (T IS X)"
  417. │   [ 1, C,X,1,X] -> [DD,1,1,0]; "BB->DD"
  418. │   [ 1, C,X,X,X] -> [AA,1,0,0]; "DD->AA"
  419. │   [ 1, C,1,X,X] -> [BB,0,1,X]; "AA->BB (T IS X)"
  420. │   [ 1, C,X,0,X] -> [CC,0,0,0]; "BB->CC"
  421. │   [ 1, C,X,1,1] -> [DD,1,1,0]; "CC->DD"
  422. │   [ 1, C,X,X,X] -> [AA,1,0,0]; "DD->AA"
  423. │
  424. │END
  425. └─
  426.  
  427. Now compile, simulate and generate a JEDEC file using ABEL.
  428.  
  429.  page 11
  430.  
  431.           Example 2 : A Mealy machine with One-Hot state assignment
  432.           ---------------------------------------------------------
  433.  
  434. In this example we will design the same state machine that we designed before,
  435. but we will use the One-Hot state assignment. for this kind of assignment
  436. we need 4 flip-flops. This time we will run ASTATER.EXE using the same command
  437. line parameters except the number of flip-flops that is 4 and the name of the
  438. machine that will be changed to M2. Here is how the command line looks:
  439.  
  440. ASTATER M2 3 3 3 2 /2 AA BB CC DD
  441.  
  442. The file that will be generated looks like the file we got earlier but with
  443. more flip-flops. All the replacements we did before will be done here too:
  444.  
  445. - Replace input1 with U
  446.  
  447. - Replace input2 with V
  448.  
  449. - Replace input3 with W
  450.  
  451. - Replace output1 with R
  452.  
  453. - Replace output2 with S
  454.  
  455. - Replace output3 with T
  456.  
  457. The main difference between this example and the previous example, is in the
  458. state assignments. Write the following one-hot state assignments:
  459.  
  460.         AA = [1,0,0,0], BB = [0,1,0,0], CC = [0,0,1,0] DD = [0,0,0,1]
  461.  
  462. Other important change that must be done (that differ from the previous
  463. example) is to change the declaration of node Q0 from ISTYPE 'REG,BUFFER' to
  464. ISTYPE 'REG,INVERT'. This change is done because we want the reset state to
  465. be AA [1,0,0,0]. When MR is invoked (MR is active-low) we want the machine to
  466. be in the AA state. In this state Q0 (the flip-flop of state AA) must be in a
  467. High (1) state.
  468.  
  469. All the other changes we had to make in this example to the original ASTATER
  470. generated source file, are the same changes we had to do in the previous
  471. example. Here are all the changes that need to be done:
  472.  
  473. - Delete WITH..ENDWITH blocks from first, third and last state blocks. These
  474.   blocks describe Moore type behavior.
  475.  
  476. - Replace dummy conditions (condition1,condition2...) and next_states
  477.   (next_state1, next_state2...) with real conditions and real next_states and
  478.   delete lines that are not needed.
  479.  
  480.  page 12
  481.  
  482. - Replace zero output assignments (Mealy and Moore type) with real output
  483.   assignments and delete output assignments that are not needed.
  484.  
  485. - Add test vector values.
  486.  
  487. Now the file will look like this:
  488.  
  489.                                     M2.ABL
  490. ┌─
  491. │MODULE M2
  492. │TITLE 'M2.ABL created by ASTATER.EXE Version 1.0
  493. │       Time of creation is Sat Aug 20 17:07:13 1994
  494. │      '
  495. │DECLARATIONS
  496. │
  497. │   M2 DEVICE ;
  498. │   U PIN ;
  499. │   V PIN ;
  500. │   W PIN ;
  501. │   CP PIN ; "CLOCK INPUT"
  502. │   MR PIN ; "MASTER RESET (ASYN) INPUT"
  503. │   R PIN ISTYPE 'COM' ;
  504. │   S PIN ISTYPE 'COM' ;
  505. │   T PIN ISTYPE 'COM' ;
  506. │   Q3 NODE ISTYPE 'REG,BUFFER' ;
  507. │   Q2 NODE ISTYPE 'REG,BUFFER' ;
  508. │   Q1 NODE ISTYPE 'REG,BUFFER' ;
  509. │   Q0 NODE ISTYPE 'REG,INVERT' ;
  510. │
  511. │   PS = [Q3,Q2,Q1,Q0] ; "STATE ASSIGNMENT"
  512. │   AA = [ 0, 0, 0, 1] ;
  513. │   BB = [ 0, 0, 1, 0] ;
  514. │   CC = [ 0, 1, 0, 0] ;
  515. │   DD = [ 1, 0, 0, 0] ;
  516. │
  517. │   C , X , P , Z = .C. , .X. , .P. , .Z. ;
  518. │
  519. │EQUATIONS
  520. │
  521. │   PS.AR = !MR ;
  522. │   PS.CLK = CP ;
  523. │  page 13
  524. │STATE_DIAGRAM PS
  525. │
  526. │   STATE AA :
  527. │      [R,S,T]=[1,0,0] ;
  528. │      CASE
  529. │         !U : AA
  530. │          U : BB
  531. │      ENDCASE ;
  532. │   STATE BB :
  533. │      [R,S]=[0,1] ;
  534. │      CASE
  535. │         !V : CC
  536. │            WITH
  537. │               T = 1 ;
  538. │            ENDWITH ;
  539. │          V : DD
  540. │            WITH
  541. │               T = 0 ;
  542. │            ENDWITH ;
  543. │      ENDCASE ;
  544. │   STATE CC :
  545. │      [R,S,T]=[0,0,0] ;
  546. │      CASE
  547. │         !V & W : CC
  548. │          V & W : DD
  549. │             !W : AA
  550. │      ENDCASE ;
  551. │   STATE DD :
  552. │      [R,S,T]=[1,1,0] ;
  553. │      CASE
  554. │         1 : AA
  555. │      ENDCASE ;
  556. │
  557. │DECLARATIONS
  558. │
  559. │   NS = [Q1,Q0] ; "NEXT STATE"
  560. │  page 14
  561. │TEST_VECTORS
  562. │
  563. │  ([MR,CP,U,V,W] -> [PS,R,S,T])
  564. │   [ 0, X,X,X,X] -> [AA,1,0,0]; "RESET"
  565. │   [ 1, C,0,X,X] -> [AA,1,0,0]; "AA->AA"
  566. │   [ 1, C,1,X,X] -> [BB,0,1,X]; "AA->BB (T IS X)"
  567. │   [ 1, 0,X,0,X] -> [BB,0,1,1]; "BB/T"
  568. │   [ 1, 0,X,1,X] -> [BB,0,1,0]; "BB/!T"
  569. │   [ 1, C,X,0,X] -> [CC,0,0,0]; "BB->CC"
  570. │   [ 1, C,X,0,1] -> [CC,0,0,0]; "CC->CC"
  571. │   [ 1, C,X,X,0] -> [AA,1,0,0]; "CC->AA"
  572. │   [ 1, C,1,X,X] -> [BB,0,1,X]; "AA->BB (T IS X)"
  573. │   [ 1, C,X,1,X] -> [DD,1,1,0]; "BB->DD"
  574. │   [ 1, C,X,X,X] -> [AA,1,0,0]; "DD->AA"
  575. │   [ 1, C,1,X,X] -> [BB,0,1,X]; "AA->BB (T IS X)"
  576. │   [ 1, C,X,0,X] -> [CC,0,0,0]; "BB->CC"
  577. │   [ 1, C,X,1,1] -> [DD,1,1,0]; "CC->DD"
  578. │   [ 1, C,X,X,X] -> [AA,1,0,0]; "DD->AA"
  579. │
  580. │END
  581. └─
  582.  
  583. Now compile, simulate and generate a JEDEC file using ABEL.
  584.  
  585.  page 15
  586.                Example 3 : A Moore machine with direct outputs
  587.                -----------------------------------------------
  588.  
  589. In this example we will be designing the following Moore machine:
  590.  
  591.  
  592.             ┌───────────────┬─────────┬┬───────────────┬─────────┐
  593.             │ Present State │  Input  ││  Next State   │ Output  │
  594.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  595.             │       AA      │   !U    ││      AA       │    R    │
  596.             │               │    U    ││      BB       │    R    │
  597.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  598.             │       BB      │   !V    ││      CC       │   S,T   │
  599.             │               │    V    ││      DD       │   S,T   │
  600.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  601.             │       CC      │ !V & W  ││      CC       │    -    │
  602.             │               │  V & W  ││      DD       │    -    │
  603.             │               │     !W  ││      AA       │    -    │
  604.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  605.             │       DD      │    1    ││      AA       │   R,S   │
  606.             └───────────────┴─────────┴┴───────────────┴─────────┘
  607.  
  608. This machine has 3 inputs an 3 outputs and behaves almost exactly like the
  609. machine from the previous examples. The only difference is that the T output
  610. dose not change as a function of V, when the machine is in the BB state (it
  611. used to change on the first and second examples).
  612.  
  613. In the previous examples the outputs of the machine were not directly the
  614. outputs of the flip-flops. Combinatorial logic was used to decode the
  615. flip-flop outputs combinations to machine output combinations (a waste of
  616. hardware resources).
  617.  
  618.  
  619.                                   CP ─>─┐
  620.                      ┌────────────────┐ │  ┌──────┐
  621.                      │  Cmbinational  ├─┼─>┤D1    ├─┬─ Q1
  622.                      │                │ ├──┤> FF  │ │
  623.                      │ Sum of product │ │  └──────┘ │
  624.                      │                ├─┼─────<─────┘ foldback
  625.             U ──────>┤     Matrix     │ │  ┌──────┐
  626.                      │                ├─┼─>┤D1    ├─┬─ Q0
  627.             V ──────>┤                │ └──┤> FF  │ │
  628.                      │                │    └──────┘ │
  629.             W ──────>┤                ├───────<─────┘ foldback
  630.                      │              d │
  631.                      │              e ├───────>─────── R
  632.                      │              c │
  633.                      │              o ├───────>─────── S
  634.                      │              d │
  635.                      │              e ├───────>─────── T
  636.                      └────────────────┘
  637.  page 16
  638.  
  639. When a design of this type is implemented with a flip-flop that has no buried
  640. registers, it wastes pins (ABEL will automatically exchange NODEs to PINs if
  641. the device has no nodes).
  642.  
  643. When designing a Moore machine, one can assign flip-flops so the outputs of
  644. machine will be directly the outputs of filp-flops.
  645.  
  646.  
  647.  
  648.                                   CP ─>─┐
  649.                      ┌────────────────┐ │  ┌──────┐
  650.                      │  Cmbinational  ├─┼─>┤DR    ├─┬─ R
  651.                      │                │ ├──┤> FF  │ │
  652.                      │ Sum of product │ │  └──────┘ │
  653.                      │                ├─┼─────<─────┘
  654.             U ──────>┤     Matrix     │ │  ┌──────┐
  655.                      │                ├─┼─>┤DS    ├─┬─ S
  656.             V ──────>┤                │ ├──┤> FF  │ │
  657.                      │                │ │  └──────┘ │
  658.             W ──────>┤                ├─┼─────<─────┘
  659.                      │                │ │  ┌──────┐
  660.                      │                ├─┼─>┤DT    ├─┬─ T
  661.                      │                │ └──┤> FF  │ │
  662.                      │                │    └──────┘ │
  663.                      │                ├───────<─────┘
  664.                      └────────────────┘
  665.  
  666. This will save pins of the PAL, reduce tpd (from the clock signal to the
  667. outputs), and produce clean outputs with no spikes. Not all outputs have to be
  668. produced this way. Some times a mixture of direct and indirect outputs is also
  669. chosen.
  670.  
  671. In this example we want all outputs to come directly from flip-flop outputs.
  672. To do this we choose to define zero outputs in the command line of ASTATER.
  673. The number of outputs defined for ASTATER is the number of indirect outputs !
  674. We also chose three flip-flops (a flip-flop for every output). This is the
  675. command and command line parameters used:
  676.  
  677. ASTATER M3 3 0 3 3 /1 AA BB CC DD
  678.  
  679.  page 17
  680.  
  681. Here is the file that will be created by ASTATER.EXE :
  682.  
  683.  
  684.                                     M3.ABL
  685. ┌─
  686. │MODULE M3
  687. │TITLE 'M3.ABL created by ASTATER.EXE Version 1.0
  688. │       Time of creation is Sat Aug 20 17:07:13 1994
  689. │      '
  690. │DECLARATIONS
  691. │
  692. │   M3 DEVICE ;
  693. │   input1 PIN ;
  694. │   input2 PIN ;
  695. │   input3 PIN ;
  696. │   CP PIN ; "CLOCK INPUT"
  697. │   MR PIN ; "MASTER RESET (ASYN) INPUT"
  698. │   Q2 NODE ISTYPE 'REG,BUFFER' ;
  699. │   Q1 NODE ISTYPE 'REG,BUFFER' ;
  700. │   Q0 NODE ISTYPE 'REG,BUFFER' ;
  701. │
  702. │   PS = [Q2,Q1,Q0] ; "STATE ASSIGNMENT"
  703. │   AA = [ 0, 0, 0] ;
  704. │   BB = [ 0, 0, 0] ;
  705. │   CC = [ 0, 0, 0] ;
  706. │   DD = [ 0, 0, 0] ;
  707. │
  708. │   C , X , P , Z = .C. , .X. , .P. , .Z. ;
  709. │
  710. │EQUATIONS
  711. │
  712. │   PS.AR = !MR ;
  713. │   PS.CLK = CP ;
  714. │  page 18
  715. │STATE_DIAGRAM PS
  716. │
  717. │   STATE AA :
  718. │      CASE
  719. │         condition11 : next_state11
  720. │         condition12 : next_state12
  721. │         condition13 : next_state13
  722. │      ENDCASE ;
  723. │   STATE BB :
  724. │      CASE
  725. │         condition21 : next_state21
  726. │         condition22 : next_state22
  727. │         condition23 : next_state23
  728. │      ENDCASE ;
  729. │   STATE CC :
  730. │      CASE
  731. │         condition31 : next_state31
  732. │         condition32 : next_state32
  733. │         condition33 : next_state33
  734. │      ENDCASE ;
  735. │   STATE DD :
  736. │      CASE
  737. │         condition41 : next_state41
  738. │         condition42 : next_state42
  739. │         condition43 : next_state43
  740. │      ENDCASE ;
  741. │
  742. │DECLARATIONS
  743. │
  744. │   NS = [Q2,Q1,Q0] ; "NEXT STATE"
  745. │
  746. │TEST_VECTORS
  747. │
  748. │   ([MR,CP,input1,input2,input3] -> NS ;
  749. │
  750. │END
  751. └─
  752.  
  753. Notice that the Mealy output assignments are missing now from the file.
  754.  
  755.  page 19
  756.  
  757. All the replacements we did in previous examples are done here in the same
  758. way:
  759.  
  760. - Replace input1 with U
  761.  
  762. - Replace input2 with V
  763.  
  764. - Replace input3 with W
  765.  
  766. - There are no replacements for output1/2/3 because they were not generated in
  767.   file
  768.  
  769. The main difference between this implementation and the previous ones is in
  770. the state assignments. Write the following state assignments:
  771.  
  772.             AA = [1,0,0], BB = [0,1,1], CC = [0,0,0], DD = [1,1,0]
  773.  
  774. In case a unique assignment for each state could not be found more flip-flops
  775. could be appended to the state register (we do not need to add flip-flops in
  776. this example).
  777.  
  778. Other important change that must be made is to change node Q0 from ISTYPE
  779. 'REG,BUFFER'to ISTYPE 'REG,INVERT'. This is because we want the reset state to
  780. be AA. When MR is invoked (low) we want the machine to be in the AA state. In
  781. this state Q0 (the flip-flop that is a direct output implementing the R output
  782. of the machine) must be in a High (1) state.
  783.  
  784. All the other changes we have to make to the original ASTATER generated file
  785. are the same changes we did in the previous examples. Here are all the changes
  786. that need to be done:
  787.  
  788. - Replace dummy conditions (condition1, condition2...) and next_states
  789.   (next_state1, next_state2...) with real conditions and next_states and
  790.   delete lines that are not needed.
  791.  
  792. - Add test vector values.
  793.  
  794.  page 20
  795.  
  796. Now the file will look like this:
  797.  
  798.                                     M3.ABL
  799. ┌─
  800. │MODULE M3
  801. │TITLE 'M3.ABL created by ASTATER.EXE Version 1.0
  802. │       Time of creation is Sat Aug 20 17:07:13 1994
  803. │      '
  804. │DECLARATIONS
  805. │
  806. │   M3 DEVICE ;
  807. │   U PIN ;
  808. │   V PIN ;
  809. │   W PIN ;
  810. │   CP PIN ; "CLOCK INPUT"
  811. │   MR PIN ; "MASTER RESET (ASYN) INPUT"
  812. │   Q2 NODE ISTYPE 'REG,INVERT' ;
  813. │   Q1 NODE ISTYPE 'REG,BUFFER' ;
  814. │   Q0 NODE ISTYPE 'REG,BUFFER' ;
  815. │
  816. │   PS = [Q2,Q1,Q0] ; "STATE ASSIGNMENT"
  817. │   AA = [ 1, 0, 0] ;
  818. │   BB = [ 0, 1, 1] ;
  819. │   CC = [ 0, 0, 0] ;
  820. │   DD = [ 1, 1, 0] ;
  821. │
  822. │   C , X , P , Z = .C. , .X. , .P. , .Z. ;
  823. │
  824. │EQUATIONS
  825. │
  826. │   PS.AR = !MR ;
  827. │   PS.CLK = CP ;
  828. │
  829. │STATE_DIAGRAM PS
  830. │  page 21
  831. │   STATE AA :
  832. │      CASE
  833. │         !U : AA
  834. │          U : BB
  835. │      ENDCASE ;
  836. │   STATE BB :
  837. │      CASE
  838. │         !V : CC
  839. │          V : DD
  840. │      ENDCASE ;
  841. │   STATE CC :
  842. │      CASE
  843. │         !V & W : CC
  844. │          V & W : DD
  845. │             !W : AA
  846. │      ENDCASE ;
  847. │   STATE DD :
  848. │      CASE
  849. │         1 : AA
  850. │      ENDCASE ;
  851. │
  852. │DECLARATIONS
  853. │
  854. │   NS = [Q2,Q1,Q0] ; "NEXT STATE"
  855. │
  856. │TEST_VECTORS
  857. │
  858. │   ([MR,CP,U,V,W] -> NS)
  859. │    [ 0, X,X,X,X] -> AA; "RESET"
  860. │    [ 1, C,0,X,X] -> AA; "AA->AA"
  861. │    [ 1, C,1,X,X] -> BB; "AA->BB"
  862. │    [ 1, C,X,0,X] -> CC; "BB->CC"
  863. │    [ 1, C,X,0,1] -> CC; "CC->CC"
  864. │    [ 1, C,X,X,0] -> AA; "CC->AA"
  865. │    [ 1, C,1,X,X] -> BB; "AA->BB"
  866. │    [ 1, C,X,1,X] -> DD; "BB->DD"
  867. │    [ 1, C,X,X,X] -> AA; "DD->AA"
  868. │    [ 1, C,1,X,X] -> BB; "AA->BB"
  869. │    [ 1, C,X,0,X] -> CC; "BB->CC"
  870. │    [ 1, C,X,1,1] -> DD; "CC->DD"
  871. │    [ 1, C,X,X,X] -> AA; "DD->AA"
  872. │
  873. │END
  874. └─
  875. Now compile, simulate and generate a JEDEC file using ABEL.
  876.  
  877.  page 21
  878.                Example 4 : A Moore mixed example
  879.                ---------------------------------
  880.  
  881. In this example we will be designing the following Moore machine:
  882.  
  883.                                  ┌─────────┐
  884.                            I ───>┤         ├──>─ P
  885.                            J ───>┤         ├──>─ Q
  886.                 Inputs     K ───>┤    M4   ├──>─ R     Outputs
  887.                            L ───>┤         ├──>─ S
  888.                            M ───>┤         ├──>─ T
  889.                                  └────┬────┘
  890.                                       │
  891.                               Cp ──>──┘
  892.  
  893.  
  894.             ┌───────────────┬─────────┬┬───────────────┬─────────┐
  895.             │ Present State │  Input  ││  Next State   │ Output  │
  896.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  897.             │       AA      │   !I    ││      AA       │    P    │
  898.             │               │    I    ││      BB       │    P    │
  899.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  900.             │       BB      │   !J    ││      BB       │    Q    │
  901.             │               │    J    ││      CC       │    Q    │
  902.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  903.             │       CC      │  I $ J  ││      DD       │    -    │
  904.             │               │  I!$ J  ││      CC       │    -    │
  905.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  906.             │       DD      │  K # L  ││      EE       │   R,T   │
  907.             │               │ !K & !L ││      DD       │   R,T   │
  908.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  909.             │       EE      │   !M    ││      EE       │   S,T   │
  910.             │               │    M    ││      FF       │   S,T   │
  911.             ├───────────────┼─────────┼┼───────────────┼─────────┤
  912.             │       FF      │    1    ││      AA       │  R,S,T  │
  913.             └───────────────┴─────────┴┴───────────────┴─────────┘
  914.  page 22
  915.  
  916. This machine has 5 inputs an 5 outputs and behaves as a moore machine.
  917.  
  918. Suppose we need that the outputs P,Q and T be clean outputs that do not
  919. produce decoding spikes (because they drive for example an asynchronous reset
  920. of a flip-flop or a write-enable input of a RAM) It is recommended to use a
  921. One-Hot state assignment for state A and B because the P and Q outputs are
  922. active only on state AA and BB. We will assign state AA to flip-flop Q2 and
  923. state BB to flip flop Q3. The outputs of the flip-flops Q2 and Q3 will be P
  924. and Q outputs respectively. The T output is not unique to only one state, so
  925. we will not be able to use a one hot assignment in order to produce it. We
  926. will just add a special flip-flop that will produce this output directly. This
  927. will be flip-flop Q4. The output of Q4 is the output T (T is a direct output).
  928.  
  929. Suppose that the other outputs are allowed to have decoding spikes (because
  930. they drive for example other synchronous devices that share the same clock).
  931. Also suppose for example, that target device has unused buried nodes. We will
  932. want to use the buried nodes and not waste any more output macrocells of the
  933. device. We can choose to fully encode the other state combinations and assign
  934. them to a pair of flip-flops called Q1 and Q0. We will assign CC to
  935. [Q1,Q0] = [0,0], DD to [Q1,Q0] = [0,1], EE to [Q1,Q0] = [1,0] and FF to
  936. [Q1,Q0] = [1,1]
  937.  
  938. When we use ASTATER.EXE we need only to declare to outputs (R and S), which
  939. are indirect outputs. All other outputs (P,Q and T) are direct flip-flop
  940. outputs. The total number of flip-flops will be 1 + 1 + 1 + 2 = 5. The number
  941. of states is 6 and number of transitions is 2. The number of inputs is 5.
  942.  
  943. The command and command line parameters used in this example are:
  944.  
  945. ASTATER M4 5 2 2 5 /1 AA BB CC DD EE FF
  946.  
  947.  page 23
  948.  
  949. Here is the file that will be created by ASTATER.EXE :
  950.  
  951.  
  952.                                     M4.ABL
  953. ┌─
  954. │MODULE M4
  955. │TITLE 'M4.ABL created by ASTATER.EXE Version 1.0
  956. │       Time of creation is Sat Aug 20 17:07:13 1994
  957. │      '
  958. │DECLARATIONS
  959. │
  960. │   M4 DEVICE ;
  961. │   input1 PIN ;
  962. │   input2 PIN ;
  963. │   input3 PIN ;
  964. │   input4 PIN ;
  965. │   input5 PIN ;
  966. │   CP PIN ; "CLOCK INPUT"
  967. │   MR PIN ; "MASTER RESET (ASYN) INPUT"
  968. │   output1 PIN ISTYPE 'COM' ;
  969. │   output2 PIN ISTYPE 'COM' ;
  970. │   Q4 NODE ISTYPE 'REG,BUFFER' ;
  971. │   Q3 NODE ISTYPE 'REG,BUFFER' ;
  972. │   Q2 NODE ISTYPE 'REG,BUFFER' ;
  973. │   Q1 NODE ISTYPE 'REG,BUFFER' ;
  974. │   Q0 NODE ISTYPE 'REG,BUFFER' ;
  975. │
  976. │   PS = [Q4,Q3,Q2,Q1,Q0] ; "STATE ASSIGNMENT"
  977. │   AA = [ 0, 0, 0, 0, 0] ;
  978. │   BB = [ 0, 0, 0, 0, 0] ;
  979. │   CC = [ 0, 0, 0, 0, 0] ;
  980. │   DD = [ 0, 0, 0, 0, 0] ;
  981. │   EE = [ 0, 0, 0, 0, 0] ;
  982. │   FF = [ 0, 0, 0, 0, 0] ;
  983. │
  984. │   C , X , P , Z = .C. , .X. , .P. , .Z. ;
  985. │
  986. │EQUATIONS
  987. │
  988. │   PS.AR = !MR ;
  989. │   PS.CLK = CP ;
  990. │
  991.  page 24
  992.  
  993. │STATE_DIAGRAM PS
  994. │
  995. │   STATE AA :
  996. │      [output1,output2] = [0,0] ;
  997. │      CASE
  998. │         condition11 : next_state11
  999. │         condition12 : next_state12
  1000. │      ENDCASE ;
  1001. │   STATE BB :
  1002. │      [output1,output2] = [0,0] ;
  1003. │      CASE
  1004. │         condition21 : next_state21
  1005. │         condition22 : next_state22
  1006. │      ENDCASE ;
  1007. │   STATE CC :
  1008. │      [output1,output2] = [0,0] ;
  1009. │      CASE
  1010. │         condition31 : next_state31
  1011. │         condition32 : next_state32
  1012. │      ENDCASE ;
  1013. │   STATE DD :
  1014. │      [output1,output2] = [0,0] ;
  1015. │      CASE
  1016. │         condition41 : next_state41
  1017. │         condition42 : next_state42
  1018. │      ENDCASE ;
  1019. │   STATE EE :
  1020. │      [output1,output2] = [0,0] ;
  1021. │      CASE
  1022. │         condition51 : next_state51
  1023. │         condition52 : next_state52
  1024. │      ENDCASE ;
  1025. │   STATE FF :
  1026. │      [output1,output2] = [0,0] ;
  1027. │      CASE
  1028. │         condition61 : next_state61
  1029. │         condition62 : next_state62
  1030. │      ENDCASE ;
  1031. │
  1032. │DECLARATIONS
  1033. │
  1034. │   NS = [Q4,Q3,Q2,Q1,Q0] ; "NEXT STATE"
  1035. │
  1036. │TEST_VECTORS
  1037. │
  1038. │   ([MR,CP,input1,input2,input3,input4,input5] -> [NS,output1,output2])
  1039. │
  1040. │END
  1041. └─
  1042.  page 25
  1043.  
  1044. Here is the file after making changes with an editor:
  1045.  
  1046.                                     M4.ABL
  1047. ┌─
  1048. │MODULE M4
  1049. │TITLE 'M4.ABL created by ASTATER.EXE Version 1.0
  1050. │       Time of creation is Sat Aug 20 17:07:13 1994
  1051. │      '
  1052. │DECLARATIONS
  1053. │
  1054. │   M4 DEVICE ;
  1055. │   I PIN ;
  1056. │   J PIN ;
  1057. │   K PIN ;
  1058. │   L PIN ;
  1059. │   M PIN ;
  1060. │   CP PIN ; "CLOCK INPUT"
  1061. │   MR PIN ; "MASTER RESET (ASYN) INPUT"
  1062. │   R PIN ISTYPE 'COM' ;
  1063. │   S PIN ISTYPE 'COM' ;
  1064. │   Q4 PIN  ISTYPE 'REG,BUFFER' ;
  1065. │   Q3 PIN ISTYPE 'REG,BUFFER' ;
  1066. │   Q2 PIN ISTYPE 'REG,INVERT' ;
  1067. │   Q1 NODE ISTYPE 'REG,BUFFER' ;
  1068. │   Q0 NODE ISTYPE 'REG,BUFFER' ;
  1069. │
  1070. │   PS = [Q4,Q3,Q2,Q1,Q0] ; "STATE ASSIGNMENT"
  1071. │   AA = [ 0, 0, 1, 0, 0] ;
  1072. │   BB = [ 0, 1, 0, 0, 0] ;
  1073. │   CC = [ 0, 0, 0, 0, 0] ;
  1074. │   DD = [ 1, 0, 0, 0, 1] ;
  1075. │   EE = [ 1, 0, 0, 1, 0] ;
  1076. │   FF = [ 1, 0, 0, 1, 1] ;
  1077. │
  1078. │   C , X , P , Z = .C. , .X. , .P. , .Z. ;
  1079. │
  1080. │EQUATIONS
  1081. │
  1082. │   PS.AR = !MR ;
  1083. │   PS.CLK = CP ;
  1084. │
  1085.  
  1086.  page 26
  1087.  
  1088. │STATE_DIAGRAM PS
  1089. │
  1090. │   STATE AA :
  1091. │      [R,S] = [0,0] ;
  1092. │      CASE
  1093. │         !I : AA
  1094. │          I : BB
  1095. │      ENDCASE ;
  1096. │   STATE BB :
  1097. │      [R,S] = [0,0] ;
  1098. │      CASE
  1099. │         !J : BB
  1100. │          J : CC
  1101. │      ENDCASE ;
  1102. │   STATE CC :
  1103. │      [R,S] = [0,0] ;
  1104. │      CASE
  1105. │         I $ J  : DD
  1106. │         I !$ J : CC
  1107. │      ENDCASE ;
  1108. │   STATE DD :
  1109. │      [R,S] = [1,0] ;
  1110. │      CASE
  1111. │          K #  L : EE
  1112. │         !K & !L : DD
  1113. │      ENDCASE ;
  1114. │    STATE EE :
  1115. │       [R,S] = [0,1] ;
  1116. │       CASE
  1117. │         !M : EE
  1118. │          M : FF
  1119. │      ENDCASE ;
  1120. │   STATE FF :
  1121. │      [R,S] = [1,1] ;
  1122. │      CASE
  1123. │         1 : AA
  1124. │      ENDCASE ;
  1125. │
  1126. │DECLARATIONS
  1127. │
  1128. │   NS = [Q4,Q3,Q2,Q1,Q0] ; "NEXT STATE"
  1129. │
  1130.  
  1131.  page 27
  1132.  
  1133. │TEST_VECTORS
  1134. │
  1135. │   ([MR,CP,I,J,K,L,M] -> [NS,R,S])
  1136. │    [ 0, X,X,X,X,X,X] -> [AA,0,0]; "P IS 1"
  1137. │    [ 1, C,0,X,X,X,X] -> [AA,0,0]; "P IS 1"
  1138. │    [ 1, C,1,X,X,X,X] -> [BB,0,0]; "Q IS 1"
  1139. │    [ 1, C,X,0,X,X,X] -> [BB,0,0]; "Q IS 1"
  1140. │    [ 1, C,X,1,X,X,X] -> [CC,0,0];
  1141. │    [ 1, C,0,0,X,X,X] -> [CC,0,0];
  1142. │    [ 1, C,1,1,X,X,X] -> [CC,0,0];
  1143. │    [ 1, C,0,1,X,X,X] -> [DD,1,0];
  1144. │    [ 1, C,X,X,0,0,X] -> [DD,1,0]; "T IS 1"
  1145. │    [ 1, C,X,X,1,1,X] -> [EE,0,1]; "T IS 1"
  1146. │    [ 1, C,X,X,0,0,0] -> [EE,0,1]; "T IS 1"
  1147. │    [ 1, C,X,X,0,0,1] -> [FF,1,1]; "T IS 1"
  1148. │    [ 1, C,X,X,X,X,X] -> [AA,0,0]; "P IS 1"
  1149. │END
  1150. └─
  1151.  
  1152. The following changes were made:
  1153.  
  1154. input1 -> I
  1155. input2 -> J
  1156. input3 -> K
  1157. input4 -> L
  1158. input5 -> M
  1159.  
  1160. output1 -> R
  1161. output2 -> S
  1162.  
  1163. State Assignment:
  1164.    AA = [ 0, 0, 1, 0, 0] ;
  1165.    BB = [ 0, 1, 0, 0, 0] ;
  1166.    CC = [ 0, 0, 0, 0, 0] ; 
  1167.    DD = [ 1, 0, 0, 0, 1] ;
  1168.    EE = [ 1, 0, 0, 1, 0] ;
  1169.    FF = [ 1, 0, 0, 1, 1] ;
  1170.  
  1171. Inserting the true outputs of R & S
  1172.  
  1173. Inserting transition conditions
  1174.  
  1175. Changing attribute of Q2 from 'REG,BUFFER' to 'REG,INVERT'
  1176.  
  1177. Changing signal type of Q4,Q3 and Q2 from NODE to PIN
  1178.  
  1179. Adding test vector values
  1180.  
  1181.  page 28
  1182.                        Errors, Warning & Note Messages
  1183.                        -------------------------------
  1184.  
  1185. If any error occurs the program will abort execution. Some errors will
  1186. generate a help screen. this is the help screen:
  1187.  
  1188. ------------------------------------usage-------------------------------------
  1189.   ASTATER <module> <in> <out> <con> <ff> /1|2 <state_name> <state_name>...
  1190. ---------------------------------parameters-----------------------------------
  1191.   <module>.........................Module name \(file_name = module_name.ABL
  1192.   <in>...............................................Number of input signals
  1193.   <out>..............Number of output signals that are not flip-flop outputs
  1194.   <cond>......................Maximum number of relevant condition per state
  1195.   <ff>..................................................Number of flip-flops
  1196.   /1|2|3...................Machine type : /1 - Moore , /2 - Mealy , /3 Dummy
  1197.   <state><state>.........................A list of state names (two or more)
  1198. ------------------------------------------------------------------------------
  1199.  
  1200. Here is a the list of errors that the program can report:
  1201.  
  1202. Error (1) : Define number of inputs.
  1203.  
  1204.             The number of inputs parameter is not defined correctly. It has to
  1205.             be an integer.
  1206.  
  1207.  
  1208. Error (2) : Define number of outputs.
  1209.  
  1210.             The number of outputs parameter is not defined correctly. It has
  1211.             to be an integer.
  1212.  
  1213.  
  1214. Error (3) : Define maximum number of transition conditions.
  1215.  
  1216.             The maximum number of outputs parameter is not defined correctly.
  1217.             It has to be an integer.
  1218.  
  1219.  
  1220. Error (4) : Define number of flip flops.
  1221.  
  1222.             The number of flip-flops parameter is not defined correctly. It
  1223.             has to be an integer.
  1224.  
  1225.  
  1226. Error (5) : Define machine type - moore (/1) or Mealy.
  1227.  
  1228.             The type of the machine is not defined correctly. It
  1229.             has to be a foreslash (/) followed by an integer.
  1230.  
  1231.  page 29
  1232.  
  1233. Error (6) : Machine type 'n' is an unknown machine_type.
  1234.  
  1235.             The type of the machine number is not defined correctly. It
  1236.             has to be a /1 (Moore) or /2 (Mealy).
  1237.  
  1238.  
  1239. Error (7) : Can't create file 'file_name' for writing.
  1240.  
  1241.  
  1242. Error (8) : Autonomous state machine is not supported.
  1243.  
  1244.             Autonomous transitions are supported, but only if they are not
  1245.             global. Read on previous text how to describe Autonomous
  1246.             transitions using the CASE..ENDCASE syntax.
  1247.  
  1248.  
  1249. Error (9) : Too many inputs.
  1250.  
  1251.             The maximum number of allowed inputs is 30.
  1252.  
  1253.  
  1254. Error (10) : Too many outputs.
  1255.  
  1256.              The maximum number of allowed outputs is 30.
  1257.  
  1258.  
  1259. Error (11) : Calculated number of transition conditions is too big.
  1260.  
  1261.              Defined number of transition conditions by user was zero. In a
  1262.              situation like this the software normally chooses a number
  1263.              that is equal to (2)^(number_of_inputs). In this case the
  1264.              calculated number is too big.
  1265.  
  1266.  
  1267. Error (12) : Too many transition conditions.
  1268.  
  1269.              The maximum number of allowed conditions is 4096.
  1270.  
  1271.  
  1272. Error (13) : No flip-flops in machine.
  1273.  
  1274.              A state machine with no Flip-Flops is not a state machine. It is
  1275.              a combinatorial system.
  1276.  
  1277.  
  1278. Error (14) : Too many flip-flops.
  1279.  
  1280.              A maximum of 30 flip-flops is allowed.
  1281.  
  1282.  page 30
  1283.  
  1284. Error (15) : 'n' states can not be assigned to only 'm' flip-flop(s).
  1285.  
  1286.              If for example you tried to declare tow flip-flops and six states
  1287.              it will not be possible to assign all six states to only four
  1288.              possible flip-flop combinations. This is because tow flip flops
  1289.              can decode only four states.
  1290.  
  1291.  
  1292. Error (16): Missing command line parameter(s).
  1293.  
  1294.             The minimum number of command line parameters must be at least 7:
  1295.  
  1296.             - number of inputs
  1297.             - number of outputs
  1298.             - maximum number of input conditions
  1299.             - number of flip-flops
  1300.             - machine type
  1301.             - a first state name
  1302.             - a second state name
  1303.  
  1304. Error (17): A Mealy type machine with no indirect outputs.
  1305.  
  1306.             Declaration of a mealy machine with no outputs is impossible
  1307.             because a mealy machine must have at least one output that depends
  1308.             on an input and not only on flip-flops.
  1309.  
  1310. Here is a list of Errorlevel that are set when exiting the program:
  1311.  
  1312.                      0 - Successful execution
  1313.                      1 - Bad numeric values of parameters
  1314.                      2 - Bad definition of parameters
  1315.                      3 - File Overwrite not allowed
  1316.                      4 - File write problems
  1317.  
  1318. Warnings & Notes will not be followed by aborting of execution. Warnings are
  1319. for making you pay attention because some thing bad might be going on. Notes
  1320. are only for informing you.
  1321.  
  1322.  page 31
  1323.  
  1324. Here is a list of Warnings that the program can report:
  1325.  
  1326.  
  1327. Warning (1) : Output file 'file_name' already exists.
  1328.  
  1329.               The user has an option to Overwrite it (by hitting the <Y> key)
  1330.               or to abort (hitting any other key)
  1331.  
  1332.  
  1333. Warning (2) : Zero outputs.
  1334.  
  1335.               Zero outputs is possible because all outputs of the machine can
  1336.               come directly from flip-flop outputs. In these cases it is
  1337.               possible for the designer to enter zero as the number of outputs
  1338.               (using the 0 command line parameter).
  1339.  
  1340. Warning (3) : The number of transition conditions was changed
  1341.               from 'm' to 'n'.
  1342.  
  1343.               If the number that defined transition conditions was zero, and
  1344.               the user defined a number of inputs that is greater then zero,
  1345.               the software will generate a canonical number of transition
  1346.               conditions = (2)^(number_of_inputs). This can be a large number.
  1347.  
  1348.               Other cases when this warning is reported are when the maximum
  1349.               number of defined state transitions is higher than it is
  1350.               possible with the defined number of inputs. For example if the
  1351.               the user defined tow inputs and five conditions a warning
  1352.               will be reported. It will tell you that the maximum number of
  1353.               conditions was decreased, to four conditions (the maximum
  1354.               possible number of conditions when the machine has tow inputs).
  1355.  
  1356.  
  1357. Here is a list of Notes that the program can report:
  1358.  
  1359. Note (1) : Machine type is Moore.
  1360.  
  1361. Note (2) : Machine type is Mealy.
  1362.  
  1363. Note (3) : Number of un-used states is: 'n'.
  1364.  
  1365.            The program calculates the difference between the largest number
  1366.            off possible flip-flop combinations and the actual number of states
  1367.            that was defined. The designer has to pay attention to these
  1368.            Hang-Up states. The machine can enter a Hang-Up state during
  1369.            power-up or as a result of noise.
  1370.  
  1371.  page 32
  1372.  
  1373.                          Limitations & Legal details
  1374.                          ---------------------------
  1375.  
  1376. The software is written by and Copyrighted to - Amos Zaslavsky. ASTATER is a
  1377. shareware. This means that you are allowed to copy it freely, and give copies to
  1378. other users.
  1379.  
  1380.        You are encouraged to do so, but with the following limitations:
  1381.  
  1382. - You must distribute ASTATER.EXE and ASTATER.DOC together and unmodified.
  1383.  
  1384. - You may not charge more than a minimal distribution fee (maximum $5.00)
  1385.   for covering disk price & postage of a diskette containing the files.
  1386.  
  1387. - You may not distribute ASTATER with or as part of other commercially sold
  1388.   software without written permission of the author.
  1389.  
  1390. - You are not permitted to sell this program for profit in any way, shape or
  1391.   form.
  1392.  
  1393. - If you like this program and use it regularly, the author would appreciate a
  1394.   contribution of $25.00, sent to the address below.
  1395.  
  1396. - As with all shareware, these contributions are the incentives for the
  1397.   author to continue developing this utility and other utilities.
  1398.  
  1399. - Contributors suggestions for enhancements will be considered in future
  1400.   versions.
  1401.  
  1402. - The author would appreciate being informed of any bugs !
  1403.  
  1404. - Future enhancements may include improovments like ABEL Symbolic-state style,
  1405.   entering input & output names, an interactive version, and other HDL's like
  1406.   PALASM and CUPUL or even C.
  1407.  
  1408.  
  1409. My address is:
  1410.                            Amos Zaslavsky
  1411.                            28 Berel Katzenelson st.
  1412.                            Haifa
  1413.                            Israel 32768
  1414.  
  1415. Telephone (voice):
  1416.                            972-4-230219
  1417.  
  1418.  
  1419.  
  1420.                                   Thank you.
  1421.  
  1422.  
  1423.  
  1424.